home *** CD-ROM | disk | FTP | other *** search
/ Aminet 33 / Aminet 33 - October 1999.iso / Aminet / gfx / show / vmpeg.lha / src / subspic.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-07-06  |  10.4 KB  |  392 lines
  1. /* #define DEBUG */
  2. /* subspic.c, Frame buffer substitution routines */
  3.  
  4. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  5.  
  6. /*
  7.  * Disclaimer of Warranty
  8.  *
  9.  * These software programs are available to the user without any license fee or
  10.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  11.  * any and all warranties, whether express, implied, or statuary, including any
  12.  * implied warranties or merchantability or of fitness for a particular
  13.  * purpose.  In no event shall the copyright-holder be liable for any
  14.  * incidental, punitive, or consequential damages of any kind whatsoever
  15.  * arising from the use of these programs.
  16.  *
  17.  * This disclaimer of warranty extends to the user of these programs and user's
  18.  * customers, employees, agents, transferees, successors, and assigns.
  19.  *
  20.  * The MPEG Software Simulation Group does not represent or warrant that the
  21.  * programs furnished hereunder are free of infringement of any third-party
  22.  * patents.
  23.  *
  24.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  25.  * are subject to royalty fees to patent holders.  Many of these patents are
  26.  * general enough such that they are unavoidable regardless of implementation
  27.  * design.
  28.  *
  29.  */
  30.  
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33.  
  34. #include "config.h"
  35. #include "global.h"
  36.  
  37. /* private prototypes*/
  38. static void Read_Frame _ANSI_ARGS_((char *filename, 
  39.   unsigned char *frame_buffer[], int framenum));
  40. static void Copy_Frame _ANSI_ARGS_((unsigned char *src, unsigned char *dst, 
  41.   int width, int height, int parity, int incr));
  42. static int Read_Components _ANSI_ARGS_ ((char *filename, 
  43.   unsigned char *frame[3], int framenum));
  44. static int Read_Component _ANSI_ARGS_ ((char *fname, unsigned char *frame, 
  45.   int width, int height));
  46. static int Extract_Components _ANSI_ARGS_ ((char *filename,
  47.   unsigned char *frame[3], int framenum));
  48.  
  49.  
  50. /* substitute frame buffer routine */
  51. void Substitute_Frame_Buffer (bitstream_framenum, sequence_framenum)
  52. int bitstream_framenum;
  53. int sequence_framenum;
  54. {
  55.   /* static tracking variables */
  56.   static int previous_temporal_reference;
  57.   static int previous_bitstream_framenum;
  58.   static int previous_anchor_temporal_reference;
  59.   static int previous_anchor_bitstream_framenum;
  60.   static int previous_picture_coding_type;
  61.   static int bgate;
  62.   
  63.   /* local temporary variables */
  64.   int substitute_display_framenum;
  65.  
  66.  
  67. #ifdef DEBUG
  68.   printf("SUB: seq fn(%d) bitfn(%d) tempref(%d) picstr(%d) type(%d)\n", 
  69.     sequence_framenum, bitstream_framenum, temporal_reference, 
  70.     picture_structure, picture_coding_type);
  71. #endif
  72.  
  73.   /* we don't substitute at the first picture of a sequence */
  74.   if((sequence_framenum!=0)||(Second_Field))
  75.   {
  76.     /* only at the start of the frame */
  77.     if ((picture_structure==FRAME_PICTURE)||(!Second_Field))
  78.     {
  79.       if(picture_coding_type==P_TYPE)
  80.       {
  81.         /* the most recently decoded reference frame needs substituting */
  82.         substitute_display_framenum = bitstream_framenum - 1;
  83.         
  84.         Read_Frame(Substitute_Picture_Filename, forward_reference_frame, 
  85.           substitute_display_framenum);
  86.       }
  87.       /* only the first B frame in a consequitve set of B pictures
  88.          loads a substitute backward_reference_frame since all subsequent
  89.          B frames predict from the same reference pictures */
  90.       else if((picture_coding_type==B_TYPE)&&(bgate!=1))
  91.       {
  92.         substitute_display_framenum = 
  93.           (previous_temporal_reference - temporal_reference) 
  94.             + bitstream_framenum - 1;
  95.  
  96.         Read_Frame(Substitute_Picture_Filename, backward_reference_frame, 
  97.           substitute_display_framenum);
  98.       }
  99.     } /* P fields can predict from the two most recently decoded fields, even
  100.          from the first field of the same frame being decoded */
  101.     else if(Second_Field && (picture_coding_type==P_TYPE))
  102.     {
  103.       /* our favourite case: the IP field picture pair */
  104.       if((previous_picture_coding_type==I_TYPE)&&(picture_coding_type==P_TYPE))
  105.       {
  106.         substitute_display_framenum = bitstream_framenum;
  107.       }
  108.       else /* our more generic P field picture pair */
  109.       {
  110.         substitute_display_framenum = 
  111.           (temporal_reference - previous_anchor_temporal_reference) 
  112.             + bitstream_framenum - 1;
  113.       }
  114.  
  115.       Read_Frame(Substitute_Picture_Filename, current_frame, substitute_display_framenum);
  116.     }
  117. #ifdef DEBUG
  118.     else if((picture_coding_type!=B_TYPE)||(picture_coding_type!=D_TYPE))
  119.     {
  120.       printf("NO SUBS FOR THIS PICTURE\n");
  121.     }
  122. #endif
  123.   }
  124.  
  125.  
  126.   /* set b gate so we don't redundantly load next time around */
  127.   if(picture_coding_type==B_TYPE)
  128.     bgate = 1;
  129.   else
  130.     bgate = 0;
  131.  
  132.   /* update general tracking variables */
  133.   if((picture_structure==FRAME_PICTURE)||(!Second_Field))
  134.   {
  135.     previous_temporal_reference  = temporal_reference;
  136.     previous_bitstream_framenum  = bitstream_framenum;
  137.   }
  138.   
  139.   /* update reference frame tracking variables */
  140.   if((picture_coding_type!=B_TYPE) && 
  141.     ((picture_structure==FRAME_PICTURE)||Second_Field))
  142.   {
  143.     previous_anchor_temporal_reference  = temporal_reference;
  144.     previous_anchor_bitstream_framenum  = bitstream_framenum;
  145.   }
  146.  
  147.   previous_picture_coding_type = picture_coding_type;
  148.  
  149. }
  150.  
  151.  
  152. /* Note: fields are only read to serve as the same-frame reference for 
  153.    a second field */
  154. static void Read_Frame(fname,frame,framenum)
  155. char *fname;
  156. unsigned char *frame[];
  157. int framenum;
  158. {
  159.   int parity;
  160.   int rerr = 0;
  161.   int field_mode;
  162.  
  163.   if(framenum<0)
  164.     printf("ERROR: framenum (%d) is less than zero\n", framenum);
  165.  
  166.  
  167.   if(Big_Picture_Flag)
  168.     rerr = Extract_Components(fname, substitute_frame, framenum);
  169.   else
  170.     rerr = Read_Components(fname, substitute_frame, framenum);
  171.  
  172.   if(rerr!=0)
  173.   {
  174.     printf("was unable to substitute frame\n");
  175.   }
  176.  
  177.   /* now copy to the appropriate buffer */
  178.   /* first field (which we are attempting to substitute) must be
  179.      of opposite field parity to the current one */
  180.   if((Second_Field)&&(picture_coding_type==P_TYPE))
  181.   {
  182.     parity      = (picture_structure==TOP_FIELD ? 1:0);      
  183.     field_mode  = (picture_structure==FRAME_PICTURE ? 0:1);
  184.   }
  185.   else
  186.   {
  187.     /* Like frame structued pictures, B pictures only substitute an entire frame 
  188.        since both fields always predict from the same frame (with respect 
  189.        to forward/backwards directions) */
  190.     parity = 0;
  191.     field_mode = 0;
  192.   }
  193.  
  194.  
  195.   Copy_Frame(substitute_frame[0], frame[0], Coded_Picture_Width, 
  196.     Coded_Picture_Height, parity, field_mode);
  197.   
  198.   Copy_Frame(substitute_frame[1], frame[1], Chroma_Width, Chroma_Height, 
  199.     parity, field_mode);
  200.   
  201.   Copy_Frame(substitute_frame[2], frame[2], Chroma_Width, Chroma_Height,
  202.     parity, field_mode);
  203.  
  204. #ifdef VERBOSE
  205.   if(Verbose_Flag > NO_LAYER)
  206.     printf("substituted %s %d\n",
  207.       (field_mode ? (parity?"bottom field":"bottom field"):"frame"), framenum);
  208. #endif
  209. }
  210.  
  211.  
  212.  
  213.  
  214. static int Read_Components(filename, frame, framenum) 
  215. char *filename;
  216. unsigned char *frame[3];
  217. int framenum;
  218. {
  219.   int err = 0;
  220.   char outname[FILENAME_LENGTH];
  221.   char name[FILENAME_LENGTH];
  222.  
  223.   sprintf(outname,filename,framenum);
  224.  
  225.  
  226.   sprintf(name,"%s.Y",outname);
  227.   err += Read_Component(name, frame[0], Coded_Picture_Width, 
  228.     Coded_Picture_Height);
  229.  
  230.   sprintf(name,"%s.U",outname);
  231.   err += Read_Component(name, frame[1], Chroma_Width, Chroma_Height);
  232.  
  233.   sprintf(name,"%s.V",outname);
  234.   err += Read_Component(name, frame[2], Chroma_Width, Chroma_Height);
  235.  
  236.   return(err);
  237. }
  238.  
  239.  
  240. static int Read_Component(Filename, Frame, Width, Height)
  241. char *Filename;
  242. unsigned char *Frame;
  243. int Width;
  244. int Height;
  245. {
  246.   int Size;
  247.   int Bytes_Read;
  248.   FILE *Infile;
  249.  
  250.   Size = Width*Height;
  251.  
  252. #ifdef DEBUG
  253.   printf("SUBS: reading %s\n", filename);
  254. #endif
  255.  
  256.   if((Infile=fopen(Filename,"rb"))==NULL)
  257.   {
  258.     printf("ERROR: unable to open reference filename (%s)\n", Filename);
  259.     return(-1);
  260.   }
  261.  
  262.   Bytes_Read = fread(Frame, 1, Size, Infile);
  263.  
  264.   if(Bytes_Read!=Size)
  265.   {
  266.     printf("was able to read only %d bytes of %d of file %s\n",
  267.            Bytes_Read, Size, Filename);
  268.   }
  269.  
  270.   fclose(Infile); 
  271.   return(0);
  272. }
  273.  
  274.  
  275. /* optimization: do not open the big file each time. Open once at start
  276.    of decoder, and close at the very last frame */
  277.  
  278. /* Note: "big" files were used in E-mail exchanges almost exclusively by the 
  279.    MPEG Committee's syntax validation and conformance ad-hoc groups from 
  280.    the year 1993 until 1995 */
  281. static int Extract_Components(filename, frame, framenum) 
  282. char *filename;
  283. unsigned char *frame[3];
  284. int framenum;
  285. {
  286. /*  int err = 0; */
  287.   FILE *fd;
  288.   int line;
  289.   int size, offset;
  290.  
  291.  
  292.   if (!(fd = fopen(filename,"rb")))
  293.   {
  294.     sprintf(Error_Text,"Couldn't open %s\n",filename);
  295.     return(-1);
  296.   }
  297.  
  298.   /* compute size of each frame (in bytes) */
  299.   size = (Coded_Picture_Width*Coded_Picture_Height);
  300.  
  301.   if(chroma_format==CHROMA444)
  302.     size = (size * 3);
  303.   else if(chroma_format==CHROMA422)
  304.     size = (size * 2);
  305.   else if(chroma_format==CHROMA420)
  306.     size = ((size*3)>>1);
  307.   else
  308.     printf("ERROR: chroma_format (%d) not recognized\n", chroma_format);
  309.  
  310.  
  311.   /* compute distance into "big" file */
  312.   offset = size*framenum;
  313.  
  314. #ifdef DEBUG
  315.   printf("EXTRACTING: frame(%d) offset(%d), size (%d) from %s\n", 
  316.     framenum, offset, size, filename);
  317. #endif
  318.  
  319.   /* seek to location in big file where desired frame begins */
  320.   /* note: this offset cannot exceed a few billion bytes due to the */
  321.   /*       obvious limitations of 32-bit integers */
  322.   fseek(fd, offset, 0);
  323.  
  324.   /* Y  */
  325.   for (line=0; line<Coded_Picture_Height; line++)
  326.   {
  327.     fread(frame[0]+(line*Coded_Picture_Width),1,Coded_Picture_Width,fd);
  328.   }
  329.  
  330.   /* Cb */
  331.   for (line=0; line<Chroma_Height; line++)
  332.   {
  333.     fread(frame[1]+(line*Chroma_Width),1,Chroma_Width,fd);
  334.   }
  335.  
  336.   /* Cr */
  337.   for (line=0; line<Chroma_Height; line++)
  338.   {
  339.     fread(frame[2]+(line*Chroma_Width),1,Chroma_Width,fd);
  340.   }
  341.  
  342.  
  343.   fclose(fd);
  344.   return(0);
  345. }
  346.  
  347.  
  348. static void Copy_Frame(src, dst, width, height, parity, field_mode)
  349. unsigned char *src;
  350. unsigned char *dst;
  351. int width;
  352. int height;
  353. int parity;        /* field parity (top or bottom) to overwrite */
  354. int field_mode;    /* 0 = frame, 1 = field                      */
  355. {
  356.   int row, col;
  357.   int s, d;
  358.   int incr;
  359.  
  360.   s = d = 0;
  361.  
  362. #ifdef DEBUG
  363.   printf("COPYING (w=%d, h=%d, parity=%d, field_mode=%d)\n",
  364.     width,height,parity,field_mode);
  365. #endif /* DEBUG */
  366.  
  367.   if(field_mode)
  368.   {
  369.     incr = 2;
  370.  
  371.     if(parity==0)
  372.       s += width;
  373.   }
  374.   else
  375.   {
  376.     incr = 1;
  377.   }
  378.  
  379.   for(row=0; row<height; row+=incr) 
  380.   {
  381.     for(col=0; col<width; col++)
  382.     {
  383.       dst[d+col] = src[s+col];
  384.     }
  385.     
  386.     d += (width*incr);
  387.     s += (width*incr);
  388.   }
  389.  
  390. }
  391.  
  392.